package server.grupo;

import persistencia.dominio.*;
import java.sql.Connection;
import java.util.*;
import persistencia.*;
import server.Control;
import server.actividades.ControlActividades;
import server.actividades.ControlActividadesGrupo;
import server.aula.ControlAula;
import utils.EnviarMail;
import utils.EnviarMailGmail;
import utils.UtilsObjetosDominio;
import comun.constantes.*;
import comun.*;
/**
 * <p>Title: </p>
 * <p>Description: </p>
 * <p>Copyright: Copyright (c) 2004</p>
 * <p>Company: </p>
 * @author unascribed
 * @version 1.0
 */
public class ControlParticipanteGrupo extends Control {
  
  private boolean debug = false;

  public ControlParticipanteGrupo(Persistencia persistencia) {
    this.persistencia=persistencia;
  }

  public ControlParticipanteGrupo(Connection conexion) {
      this.conexionSQL = conexion;
  }

  public ControlParticipanteGrupo(Persistencia persistencia, Connection conexion) {
	    this.persistencia=persistencia;
	    this.conexionSQL = conexion;
	  }

  

  public String restaurarExcluido(Long idExcluido) throws Exception{
	        ParticipanteExcluido partExcl = (ParticipanteExcluido)persistencia.getObjectoPorId("persistencia.dominio.ParticipanteExcluido",idExcluido);
	        if(partExcl.getTipoExclusion().getNombre().compareTo(TIPO_EXCLUSION.RECHAZADO)==0){
	        	ParticipanteComision participanteComisionNuevo = new ParticipanteComision();
				persistencia.hacerPersistente(participanteComisionNuevo);
				Grupo grupo = partExcl.getGrupo();
				ControlGrupo controlGrupo = new ControlGrupo(this.persistencia);
				participanteComisionNuevo.setTipoUsuario(controlGrupo.getTipoUsuario(TIPO_USUARIOS.PARTICIPANTE_INVITADO_O_INTERESADO));
				participanteComisionNuevo.setComision(grupo);
				participanteComisionNuevo.setParticipante(partExcl.getParticipante());
				grupo.setIdEnConfiguracion(null);
				/*Aca debemos ver si asociamos las actividades al nuevo Integrante del grupo*/
				ControlActividadesGrupo controlActividadesGrupo = new ControlActividadesGrupo(this.persistencia);
				ControlActividades controlActividades = new ControlActividades(this.persistencia);
				Vector actividGrupo = controlActividadesGrupo.getActividadesGrupalesDelGrupo(grupo.getId(),null,false,null);
				for (Iterator i = actividGrupo.iterator(); i.hasNext();) {
					Actividad activ = (Actividad) i.next();
					Nota nota = new Nota();
					persistencia.hacerPersistente(nota);
					nota.setActividad(activ);
					nota.setPersona(participanteComisionNuevo.getParticipante().getPersona());
					nota.setEstadoNota(controlActividades.getEstadoAulaCerrada());
				}
				/*Aca estaria bueno enviar el mail a la persona interesada diciendo que ya es integrante del grupo*/
				//EnviarMail enviarMail  = new EnviarMail();
				EnviarMailGmail enviarMailGmail = new EnviarMailGmail();
		        //enviarMail.sendMail(partExcl.getParticipante().getPersona().getEmail(),"info@siat.unrc.edu.ar",TEXTOS.ASUNTO_RESTAURACION_RECHAZO_MAIL_DE_SOLICITUD,TEXTOS.CUERPO_RESTAURACION_RECHAZO_MAIL_DE_SOLICITUD);
		        enviarMailGmail.enviandoMail(true, partExcl.getParticipante().getPersona().getEmail(), TEXTOS.ASUNTO_RESTAURACION_RECHAZO_MAIL_DE_SOLICITUD,TEXTOS.CUERPO_RESTAURACION_RECHAZO_MAIL_DE_SOLICITUD, "info@siat.unrc.edu.ar");
	        }
	        persistencia.deletePersistente(partExcl);
	        return TEXTOS.ELIMINACION_DE_DATOS_EXITOSA;
	  }

  
  public String autoinscripcionComun(Long idGrupo, Long idPersona, Long idAulaOComision, boolean inter, String tipoUsuario) throws Exception{

		  ControlAula controlAula = new ControlAula(this.persistencia);
		  ControlGrupo controlGrupo = new ControlGrupo(this.persistencia);
		  Participante participante = null;
		  
		  Grupo grupo = (Grupo)persistencia.getObjectoPorId("persistencia.dominio.Grupo",idGrupo);
		  
		  if(inter) participante = controlAula.getParticipante(idAulaOComision, idPersona);
		  else participante = ((ParticipanteComision)controlAula.getParticipanteComision(idAulaOComision, idPersona)).getParticipante();
		  
		  ParticipanteComision participanteComisionNuevo = new ParticipanteComision();
		  persistencia.hacerPersistente(participanteComisionNuevo);
		  
		  if(grupo.getParticipanteComisiones().size()==0)
			  participanteComisionNuevo.setTipoUsuario(controlGrupo.getTipoUsuario(TIPO_USUARIOS.LIDER));
		  else participanteComisionNuevo.setTipoUsuario(controlGrupo.getTipoUsuario(TIPO_USUARIOS.PARTICIPANTE));
		  
		  //participanteComisionNuevo.setTipoUsuario(controlGrupo.getTipoUsuario(tipoUsuario));
		  participanteComisionNuevo.setComision(grupo);
		  participanteComisionNuevo.setParticipante(participante);
		  grupo.setIdEnConfiguracion(null);
		  return comun.constantes.TEXTOS.ACTUALIZACION_DE_DATOS_EXITOSA;
	
  }

  public Long autoinscripcionDirigida(Long idPersona,Long idAula, Long idComision, boolean inter, String[] temasElegidos, String obser) throws Exception{

		  ControlGrupo controlGrupo = new ControlGrupo(this.persistencia);
		  ControlAula controlAula = new ControlAula(this.persistencia);
		  Participante participante = null;
		  Vector grupos = null;
		  		  
		  participante = ((ParticipanteComision)controlAula.getParticipanteComision(idComision, idPersona)).getParticipante();
		  grupos = controlGrupo.getGruposComisionTema(idAula,idComision,temasElegidos);
		  
		  
		  Grupo grupoLimitado = null;
		  Grupo grupoSinLimite = null;//Grupo de mayor espacio para integrantes de los SL
		  
		  //Elijo el mejor caso de grupo para agregarle el participante que se esta autoinscribiendo
		  for(Iterator i = grupos.iterator(); i.hasNext();) {
			Grupo grupo = (Grupo) i.next();
			
			if((grupo.getParticipanteComisiones().size() < grupo.getMaxCantIntegr().intValue()) &&
					!this.personaEsIntegranteDelGrupo(grupo.getId(),idPersona)){
				
				if(grupo.getMaxCantIntegr().intValue() == CONSTANTES_ENTERAS.CANTIDAD_SIN_LIMITE_INTEGRANTES_CONFIGURACION){//Sin limite
					if(grupoSinLimite == null ||
					  (grupo.getMaxCantIntegr().intValue() - grupo.getParticipanteComisiones().size()) >
					  (grupoSinLimite.getMaxCantIntegr().intValue() - grupoSinLimite.getParticipanteComisiones().size()))
						
						grupoSinLimite = grupo;
				}else{//Limite fijo
					if(grupoLimitado == null || 
					  (grupo.getMaxCantIntegr().intValue() - grupo.getParticipanteComisiones().size()) >
					  (grupoLimitado.getMaxCantIntegr().intValue() - grupoLimitado.getParticipanteComisiones().size()))
						
						grupoLimitado = grupo;
				}			
				//break;
			}
		  }
		  if(grupoLimitado == null && grupoSinLimite == null)
			  return new Long(-1);
		  ParticipanteComision participanteComisionNuevo = new ParticipanteComision();
		  if(obser != null)
			  participanteComisionNuevo.setObservacion(obser);
		  persistencia.hacerPersistente(participanteComisionNuevo);
		  //Analizamos con cual de los dos grupos nos quedamos
		  if(grupoLimitado == null)
			  grupoLimitado = grupoSinLimite;
		  else{
			  if(grupoSinLimite != null){
				  if(grupoSinLimite.getParticipanteComisiones().size() < grupoLimitado.getParticipanteComisiones().size())
					  grupoLimitado = grupoSinLimite;
			  }
		  }
		  if(grupoLimitado.getParticipanteComisiones().size()==0)
			  participanteComisionNuevo.setTipoUsuario(controlGrupo.getTipoUsuario(TIPO_USUARIOS.LIDER));
		  else participanteComisionNuevo.setTipoUsuario(controlGrupo.getTipoUsuario(TIPO_USUARIOS.PARTICIPANTE));
		  participanteComisionNuevo.setComision(grupoLimitado);
		  participanteComisionNuevo.setParticipante(participante);
		  grupoLimitado.setIdEnConfiguracion(null);
		  return grupoLimitado.getId();
	
  }

  
  public String atraparCurioso(Grupo grupo, Participante participante){
	  try{
		  ParticipanteExcluido participanteCurioso = new ParticipanteExcluido();
          persistencia.hacerPersistente(participanteCurioso);
          TipoExclusion  tipoExclusion = (TipoExclusion)persistencia.getObjectosPorClaseYFiltro("persistencia.dominio.TipoExclusion","nombre ==\""+TIPO_EXCLUSION.CURIOSO+"\"").elementAt(0);
          participanteCurioso.setFechaAltaExclusion(utils.Utils.hoySqlDate());
          participanteCurioso.setFechaUltimoAcceso(utils.Utils.hoySqlDate());
          participanteCurioso.setParticipante(participante);
          participanteCurioso.setGrupo(grupo);
          participanteCurioso.setTipoExclusion(tipoExclusion);
    	  return comun.constantes.TEXTOS.ACTUALIZACION_DE_DATOS_EXITOSA;
	  }catch (Exception ex) {
	    ex.printStackTrace();
	    persistencia.rollback();
	    return MensajeDeError.ERROR_EN_LA_ACTUALIZACION_DE_DATOS;
	  }
  }

  public String actualizarCurioso(ParticipanteExcluido participanteCurioso){
	  try{
		  participanteCurioso.setFechaUltimoAcceso(utils.Utils.hoySqlDate());
		  return comun.constantes.TEXTOS.ACTUALIZACION_DE_DATOS_EXITOSA;
	  }catch (Exception ex) {
	    ex.printStackTrace();
	    persistencia.rollback();
	    return MensajeDeError.ERROR_EN_LA_ACTUALIZACION_DE_DATOS;
	  }
  }

  /*Vacio los grupos del Aula dada, donde vaciar significa limpiar de participantes todos estos grupos*/
  public String vaciarGruposDelAula(Long idAula,String estado) throws Exception{
		  ControlGrupo controlGrupo = new ControlGrupo(this.persistencia);
		  Vector grupos = controlGrupo.getGruposDelAula(idAula,estado,false);
		  ControlAula controlAula = new ControlAula(this.persistencia);
		  Vector comisiones = controlAula.getComisionesDelAula(idAula);
		  for (Iterator i = comisiones.iterator(); i.hasNext();) {
				Comision comision = (Comision) i.next();
				grupos.addAll(controlGrupo.getGruposDeLaComision(comision.getId(),null,estado));
		  }
		  for (Iterator iter = grupos.iterator(); iter.hasNext();) {
			  Grupo grupo = (Grupo) iter.next();
			  if(grupo.getIntercom().booleanValue()) grupo.setIdEnConfiguracion(idAula);
			  else grupo.setIdEnConfiguracion(controlGrupo.getComisionDelGrupo(grupo.getId()).getId());
			  for (Iterator iter2 = grupo.getParticipanteComisiones().iterator(); iter2.hasNext();) {
				  ParticipanteComision pc = (ParticipanteComision) iter2.next();
				  persistencia.deletePersistente(pc);
			  }
		  }
		  return TEXTOS.ACTUALIZACION_DE_DATOS_EXITOSA;
  }

  public String vaciarGrupo(Long idGrupo) throws Exception{

		  ControlGrupo controlGrupo = new ControlGrupo(this.persistencia);
		  Grupo grupo = controlGrupo.getGrupo(idGrupo); 
		  if(grupo.getIntercom().booleanValue()) grupo.setIdEnConfiguracion(((ParticipanteComision)grupo.getParticipanteComisiones().iterator().next()).getParticipante().getAula().getId());
		  else grupo.setIdEnConfiguracion(controlGrupo.getComisionDelGrupo(grupo.getId()).getId());
		  for (Iterator iter2 = grupo.getParticipanteComisiones().iterator(); iter2.hasNext();) {
			  ParticipanteComision pc = (ParticipanteComision) iter2.next();
			  persistencia.deletePersistente(pc);
		  }
		  return TEXTOS.ACTUALIZACION_DE_DATOS_EXITOSA;
	   
  }

  
  /*Vacio los grupos de la Comision dada, donde vaciar significa limpiar de participantes todos estos grupos*/
  public String vaciarGruposDeLaComision(Long idComision,String estado) throws Exception{
	  Vector grupos = new Vector();
	  ControlGrupo controlGrupo = new ControlGrupo(this.persistencia);
		 grupos = controlGrupo.getGruposSoloDeLaComision(idComision,false,false);
		 for (Iterator iter = grupos.iterator(); iter.hasNext();) {
			  Grupo grupo = (Grupo) iter.next();
			  if(grupo.getIntercom().booleanValue()) grupo.setIdEnConfiguracion(((ParticipanteComision)grupo.getParticipanteComisiones().iterator().next()).getParticipante().getAula().getId());
			  else grupo.setIdEnConfiguracion(idComision);
			  for (Iterator iter2 = grupo.getParticipanteComisiones().iterator(); iter2.hasNext();) {
				  ParticipanteComision pc = (ParticipanteComision) iter2.next();
				  persistencia.deletePersistente(pc);
			  }
		  }
		  return TEXTOS.ACTUALIZACION_DE_DATOS_EXITOSA;

  }
  
  //////////////////////METODOS DE CONSULTA////////////////////////////////////////////////
  
  public Vector getParticipantesExcluidosDelGrupo(Long idGrupo, String tipoExclusion)throws Exception{
		  String filtro=
	        "grupo.id == "+idGrupo;
	      if (tipoExclusion != null)
			  filtro += " & tipoExclusion.nombre ==\""+tipoExclusion+"\"";
		  Vector excluidos = persistencia.getObjectosPorClaseYFiltro
	        	("persistencia.dominio.ParticipanteExcluido","",filtro,null);
	      return excluidos;
  }

  public ParticipanteExcluido participanteEsExcluidoDelGrupo(Long idGrupo, Long idPersona, String exclusion)throws Exception{

		 	Vector resultado;
			String filtro=
	           "participante.persona.id == "+idPersona+
	           " & grupo.id == "+idGrupo;
	        filtro += " & tipoExclusion.nombre ==\""+exclusion+"\"";
			resultado = persistencia.getObjectosPorClaseYFiltro
	             ("persistencia.dominio.ParticipanteExcluido","participante.persona.nombre",filtro,null);
			if(resultado.isEmpty())
				return null;
			else
				return (ParticipanteExcluido)resultado.elementAt(0);
	}

  /*ASUNTO CONFIGURACION DE PERMISOS: GRUPO COMO RECURSO Y RECURSOS DE LOS GRUPOS*/
  public boolean personaEsIntegranteDelGrupo(Long idGrupo, Long idPersona)throws Exception{

		  	Vector resultado = new Vector();
			String filtro=
	           "persona.id == "+idPersona+
	           " & participanteComisiones.contains(participanteComision) "+
	  	       " & participanteComision.comision.id == "+idGrupo;

			String vars= "persistencia.dominio.ParticipanteComision participanteComision";

			resultado = persistencia.getObjectosPorClaseYFiltro
	             ("persistencia.dominio.Participante","persona.nombre",filtro,vars);
			if(resultado.isEmpty())
				return false;
			return true;
	} 

    
  /*Dado el grupo y el rol de los integrantes (o del integrante) que queremos buscar, el metodo retorna los
  integrantes (o del integrante) que tienen dicho rol en dicho grupo. Si buscamos el lider o el lider suplente,
  el metodo retorna un vector con un unico elemento o puede darse que se retorne un vector vacio, ya que un
  grupo puede que no tenga un lider suplente. En caso de que pasemos el rol como null, el metodo me retorna
  todos los integrantes del Grupo pasado como patrametro*/
  public Vector getPersonaRolGrupo(Long idGrupo, String rol)throws Exception{
		  String filtro=
	        "comision.id == "+idGrupo;
	      if (rol != null)
			  filtro += " & tipoUsuario.nombre ==\""+rol+"\"";
		  Vector participantesConRol = persistencia.getObjectosPorClaseYFiltro
	        	("persistencia.dominio.ParticipanteComision","",filtro,null);
	      return participantesConRol;
  }
  

  //Dado el id de un participante, obtengo el Participante
  public Participante getParticipante(Long idParticipante) throws Exception{
      return (Participante)persistencia.getObjectoPorId("persistencia.dominio.Participante",idParticipante);
  }

  /**
   * retiorna las personas que tiene el tipo de usuario "tipoUsuario" en la comision idComision
   * @param idComision
   * @param tipoUsuario si es null recupera todos los participantes
   * @return
   * @throws Exception
   */
  public Vector getParticipanteAulaConTipoDeUsuario(Long idAula, String tipoUsuario) throws Exception{
   	  String filtro=
            "aula.id == "+idAula +
            " & persona != null "+
   	        " & tipoUsuario.nombre == \""+ tipoUsuario+"\"";
      Vector participantes = persistencia.getObjectosPorClaseYFiltro
                ("persistencia.dominio.Participante","persona.apellido",filtro);
      return participantes;
  }

  public Vector getParticipanteAulaConTipoDeUsuario(Long idAula, String tipoUsuario, String opcion) throws Exception{
	   	  String filtro=
	            "aula.id == "+idAula +
	            " & persona != null "+
	   	        " & tipoUsuario.nombre == \""+ tipoUsuario+"\"";
	   	  String ordenarPor = "persona.apellido";
	   	  if(opcion.compareTo(OPCION_AUTOCOMPLETADO.AL_AZAR)==0){
	   		ordenarPor = "persona.calle";
	   	  }else if(opcion.compareTo(OPCION_AUTOCOMPLETADO.ALFABETICAMENTE)==0){
  		  	ordenarPor = "persona.apellido";
		  }else if(opcion.compareTo(OPCION_AUTOCOMPLETADO.GEOGRAFICAMENTE)==0){
			  ordenarPor = "persona.ciudad.nombre";
		  }else if(opcion.compareTo(OPCION_AUTOCOMPLETADO.EDADES)==0){
			  ordenarPor = "persona.fechaNacimiento";
		  }
	      Vector participantes = persistencia.getObjectosPorClaseYFiltro
	                ("persistencia.dominio.Participante",ordenarPor,filtro);
	      return participantes;
	  }


  /*Dado el el grupo que esta en el combox y el id del aula, me retorna todos los alumnos de dicha aula
  que pueden ser integrados al grupo*/
  public Vector getParticipantesDelAulaPosiblesAIntegrarEnElGrupoIntercomision(Long idAula, Grupo grupo) throws Exception{
	  ControlGrupo controlGrupo = new ControlGrupo(this.persistencia);
	  //Obtengo todos los alumnos del Aula
	  Vector alumnosDelAula = this.getParticipanteAulaConTipoDeUsuario(idAula, TIPO_USUARIOS.ALUMNO);
	  Vector grupos = controlGrupo.getGruposDelAula(idAula, ESTADO_GRUPOS.VISIBLE,false);
	  UtilsObjetosDominio.eliminarObjetoAVector(grupo, grupos);
	  //En este vector junto los objetos participante que no podran ser integrados (por alguna razon)
	  //al grupo que actualmente esta en el combox
	  Vector participantesImposiblesDeIntegrar = new Vector();
	  //Agrego los participantes que ya estan inscriptos en el grupo
	  for (Iterator i = grupo.getParticipanteComisiones().iterator(); i.hasNext();) {
		ParticipanteComision pc = (ParticipanteComision) i.next();
		participantesImposiblesDeIntegrar.add(pc.getParticipante());
	  }
	  
	  //El Grupo que le estamos asignando integrantes NO permite que lo integren alumnos que esten en otrso grupos, por
	  //lo tanto, todo alumno inscripto en otro grupo se agregara a "participantesImposiblesDeIntegrar". 
	  if(!grupo.getMultiGrupos().booleanValue()){
		  for (Iterator i = grupos.iterator(); i.hasNext();) {
				Grupo gr = (Grupo) i.next();
				for (Iterator j = gr.getParticipanteComisiones().iterator(); j.hasNext();) {
					ParticipanteComision pc = (ParticipanteComision) j.next();
					participantesImposiblesDeIntegrar.add(pc.getParticipante());
				}
		  }
	  //Solo debemos controlar de no obtener integrantes de grupos que los mismos no permiten Multigrupo
	  }else{
		  //Recorro todos los grupos y agrego al vector de participantesImposiblesDeIntegrar todos
		  //los integrantes de los grupos que pueden no ser inscriptos en otros grupos
		  for (Iterator i = grupos.iterator(); i.hasNext();) {
			Grupo gr = (Grupo) i.next();
			if(!gr.getMultiGrupos().booleanValue()){
				for (Iterator j = gr.getParticipanteComisiones().iterator(); j.hasNext();) {
					ParticipanteComision pc = (ParticipanteComision) j.next();
					participantesImposiblesDeIntegrar.add(pc.getParticipante());
				}
			}
		  }
	  }
	  Vector prohibidos = this.getParticipantesExcluidosDelGrupo(grupo.getId(),TIPO_EXCLUSION.PROHIBIDO);
	  for (Iterator i = prohibidos.iterator(); i.hasNext();) {
		  ParticipanteExcluido exclu = (ParticipanteExcluido) i.next();
		  participantesImposiblesDeIntegrar.add(exclu.getParticipante());
	  }
	  //Al vector de alumnos del aula, le quito todos los alumnos que por alguna razon no se pueden
	  //inscribir en el grupo del combox
	  return UtilsObjetosDominio.resta(alumnosDelAula, participantesImposiblesDeIntegrar);
  }

  /*Dado el idComision, me retorno los alumnos participantes de esa comision*/
  public Vector getParticipantesComision(Long idComision, String tipoUsuario) throws Exception{
      String filtro=
          " participanteComisiones.contains(participanteComision)"+
          " & participanteComision.comision.id == "+idComision +
          " & persona != null "+
          " & tipoUsuario.nombre == \""+ tipoUsuario+"\"";
      String vars="ParticipanteComision participanteComision";
      Vector participantes = persistencia.getObjectosPorClaseYFiltro
              ("persistencia.dominio.Participante","persona.apellido",filtro,vars);
      return participantes;
  }

  public Vector getIntegrantesDelGrupo(Long idGrupo) throws Exception{
	      String filtro=
	          "comision.id == "+idGrupo +
	          " & participante.persona != null ";
	      Vector participantes = persistencia.getObjectosPorClaseYFiltro
	              ("persistencia.dominio.ParticipanteComision","participante.persona.apellido",filtro,null);
	      return participantes;
	  }
  
  public Vector getParticipantesComision(Long idComision, String tipoUsuario, String opcion) throws Exception{
	      String filtro=
	          " participanteComisiones.contains(participanteComision)"+
	          " & participanteComision.comision.id == "+idComision +
	          " & persona != null "+
	          " & tipoUsuario.nombre == \""+ tipoUsuario+"\"";
	      String vars = "ParticipanteComision participanteComision";
	      String ordenarPor = "persona.apellido";
	   	  if(opcion.compareTo(OPCION_AUTOCOMPLETADO.AL_AZAR)==0){
	   		ordenarPor = "persona.calle";
	   	  }else if(opcion.compareTo(OPCION_AUTOCOMPLETADO.ALFABETICAMENTE)==0){
  		  	ordenarPor = "persona.apellido";
		  }else if(opcion.compareTo(OPCION_AUTOCOMPLETADO.GEOGRAFICAMENTE)==0){
			  ordenarPor = "persona.ciudad.nombre";
		  }else if(opcion.compareTo(OPCION_AUTOCOMPLETADO.EDADES)==0){
			  ordenarPor = "persona.fechaNacimiento";
		  }
	      Vector participantes = persistencia.getObjectosPorClaseYFiltro
          						("persistencia.dominio.Participante",ordenarPor,filtro,vars);
	      return participantes;
	  }

  /*Dado el id del Grupo que esta en el combox y el id de la comision, me retorna todos los alumnos de dicha comision
  que pueden ser integrados al grupo*/
  public Vector getParticipantesDeLaComisionPosiblesAIntegrarEnElGrupoComision(Long idComision, Grupo grupo) throws Exception{
	  ControlGrupo controlGrupo = new ControlGrupo(this.persistencia);
	  //Obtengo todos los alumnos del Aula
	  Vector alumnosDeLaComision = this.getParticipantesComision(idComision, TIPO_USUARIOS.ALUMNO);
	  Vector grupos = controlGrupo.getGruposDeLaComision(idComision, null, ESTADO_GRUPOS.VISIBLE);
	  UtilsObjetosDominio.eliminarObjetoAVector(grupo, grupos);
	  //En este vector junto los objetos participante que no podran ser integrados (por alguna razon)
	  //al grupo que actualmente esta en el combox
	  Vector participantesImposiblesDeIntegrar = new Vector();
	  //Agrego los participantes que ya estan inscriptos en el grupo
	  for (Iterator i = grupo.getParticipanteComisiones().iterator(); i.hasNext();) {
		ParticipanteComision pc = (ParticipanteComision) i.next();
		participantesImposiblesDeIntegrar.add(pc.getParticipante());
	  }
	  //El Grupo que le estamos asignando integrantes NO permite que lo integren alumnos que esten en otrso grupos, por
	  //lo tanto, todo alumno inscripto en otro grupo se agregara a "participantesImposiblesDeIntegrar". 
	  if(!grupo.getMultiGrupos().booleanValue()){
		  for (Iterator i = grupos.iterator(); i.hasNext();) {
				Grupo gr = (Grupo) i.next();
				for (Iterator j = gr.getParticipanteComisiones().iterator(); j.hasNext();) {
					ParticipanteComision pc = (ParticipanteComision) j.next();
					participantesImposiblesDeIntegrar.add(pc.getParticipante());
				}
		  }
	  //Solo debemos controlar de no obtener integrantes de grupos que los mismos no permiten Multigrupo
	  }else{
		  //Recorro todos los grupos y agrego al vector de participantesImposiblesDeIntegrar todos
		  //los integrantes de los grupos que pueden no ser inscriptos en otros grupos
		  for (Iterator i = grupos.iterator(); i.hasNext();) {
			Grupo gr = (Grupo) i.next();
			if(!gr.getMultiGrupos().booleanValue()){
				for (Iterator j = gr.getParticipanteComisiones().iterator(); j.hasNext();) {
					ParticipanteComision pc = (ParticipanteComision) j.next();
					participantesImposiblesDeIntegrar.add(pc.getParticipante());
				}
			}
		  }
	  }
	  Vector prohibidos = this.getParticipantesExcluidosDelGrupo(grupo.getId(),TIPO_EXCLUSION.PROHIBIDO);
	  for (Iterator i = prohibidos.iterator(); i.hasNext();) {
		  ParticipanteExcluido exclu = (ParticipanteExcluido) i.next();
		  participantesImposiblesDeIntegrar.add(exclu.getParticipante());
	  }
	  //Al vector de alumnos del aula, le quito todos los alumnos que por alguna razon no se pueden
	  //inscribir en el grupo del combox
	  return UtilsObjetosDominio.resta(alumnosDeLaComision, participantesImposiblesDeIntegrar);
	}

  	/*Dado el participante, saber a que grupos pertenece*/
  	public Vector getGruposDelParticipante(Long idParticipante) throws Exception{
  		//Aula aula = ((Participante)persistencia.getObjectoPorId("persistencia.dominio.Participante",idParticipante)).getAula();
  		String filtro =
            " participanteComisiones.contains(participanteComisionGrupo)"+
            //Para obtener grupos que tengan como integrante al participante en cuestion
            " & participanteComisionGrupo.participante.id == "+idParticipante;
            //Solo se traeran los grupos que pertencen al aula del participante en cuestion. NO es necesario
  		    //porque un Participante pertenece a una unica Aula; por lo tanto TODOS los grupos que se traeran
  		    //perteneceran a la Unica Aula a la cual pertenece el integrante...
  		    //" & participanteComisionGrupo.participante.aula == "+aula.getId();
        String vars = "ParticipanteComision participanteComisionGrupo";
        Vector grupos = persistencia.getObjectosPorClaseYFiltro
                ("persistencia.dominio.Grupo","nombre",filtro,vars);
        return grupos;
  	}

  	public Vector getGruposDelParticipanteEnEstado(Long idParticipante, String estado) throws Exception{
  		//Aula aula = ((Participante)persistencia.getObjectoPorId("persistencia.dominio.Participante",idParticipante)).getAula();
  		String filtro =
            " participanteComisiones.contains(participanteComisionGrupo)"+
            //Para obtener grupos que tengan como integrante al participante en cuestion
            " & participanteComisionGrupo.participante.id == "+idParticipante;
            //Solo se traeran los grupos que pertencen al aula del participante en cuestion. NO es necesario
  		    //porque un Participante pertenece a una unica Aula; por lo tanto TODOS los grupos que se traeran
  		    //perteneceran a la Unica Aula a la cual pertenece el integrante...
  		    //" & participanteComisionGrupo.participante.aula == "+aula.getId();
  		if(estado!=null){
            if(estado.compareTo(ESTADO_GRUPOS.VISIBLE)==0)
			     filtro += " & (estadoGrupo.descripcion == \""+ estado+"\"" +
		 		   " | estadoGrupo.descripcion == \""+ ESTADO_GRUPOS.NO_VISIBLE+"\")";
			else filtro += " & estadoGrupo.descripcion == \""+estado+"\"";
		}else
			 filtro += " & estadoGrupo.descripcion != \""+ ESTADO_GRUPOS.ELIMINADO+"\"";
        String vars = "ParticipanteComision participanteComisionGrupo";
        Vector grupos = persistencia.getObjectosPorClaseYFiltro
                ("persistencia.dominio.Grupo","nombre",filtro,vars);
        return grupos;
  	}
  	
  	/*Dado el participante, saber si puede ser o no invitado o solicitado para que integre otro grupo, teniendo en
  	cuenta la configuracion de los grupos a los que grupos pertenece*/
  	public Boolean getParticipantePuedeIntegrarseAOtroGrupo(Long idParticipante) throws Exception{
  		String filtro=
            " participanteComisiones.contains(participanteComisionGrupo)"+
            " & participanteComisionGrupo.participante.id == "+idParticipante;
        String vars="ParticipanteComision participanteComisionGrupo";
        Vector grupos = persistencia.getObjectosPorClaseYFiltro
                ("persistencia.dominio.Grupo","nombre",filtro,vars);
        for (Iterator i = grupos.iterator(); i.hasNext();) {
			Grupo grupo = (Grupo) i.next();
			if(!grupo.getMultiGrupos().booleanValue())
				return Boolean.FALSE;
		}
        return Boolean.TRUE;
  	}


  	public boolean esParticipanteDelGrupo(Long idGrupo, Long idParticipante)throws Exception{
 		  	Vector resultado = new Vector();
  			String filtro=
  			   "participante.id == "+idParticipante+
  	           " & comision.id == "+idGrupo;
  			resultado = persistencia.getObjectosPorClaseYFiltro
	             ("persistencia.dominio.ParticipanteComision","participante.persona.nombre",filtro,null);
  			return !resultado.isEmpty();
  	}

  	public ParticipanteComision getObjetoParticipanteGrupo(Long idGrupo, Long idParticipante)throws Exception{
  		  String filtro=
  	        "comision.id == "+idGrupo;
  		  filtro += " & participante.id == "+idParticipante;
  	      return (ParticipanteComision)persistencia.getObjectosPorClaseYFiltro("persistencia.dominio.ParticipanteComision","",filtro,null).firstElement();
    }
}